import java.util.Scanner;

public class day7 {

    // 58： BC61 金字塔图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的金字塔图案。
    输入描述：
    多组输入，一个整数（2~20），表示金字塔边的长度，即“ * ”的数量，，也表示输出行数。
    输出描述：
    针对每行输入，输出用“ * ”组成的金字塔，每个“ * ”后面有一个空格。
    示例1
    输入：
    4
    输出：
    *
    **
    ***
    ****
    示例2
    输入：
    5
    输出：
    *
    **
    ***
    ****
    *****
    */
    public static void main58(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                // 打印空格
                for (int j = 0; j < n - i - 1; j++) {
                    System.out.print(" ");
                }

                // 处理星号
                for (int j = 0; j <= i; j++) {
                    System.out.print("* ");
                }
                System.out.println();
            }
        }
    }


    // 59: BC62 翻转金字塔图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的翻转金字塔图案。
    输入描述：
    多组输入，一个整数（2~20），表示翻转金字塔边的长度，即“ * ”的数量，也表示输出行数。
    输出描述：
    针对每行输入，输出用“ * ”组成的金字塔，每个“ * ”后面有一个空格。
    示例1
    输入：
    5
    输出：
    * ****
    ****
    ***
    **
    *
    示例2
    输入：
    6
    输出：
    * *****
    *****
    ****
    ***
    **
    *
    */

    public static void main59(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            for (int i = 0; i < n; i++) {
                // 处理空格
                for (int j = 0; j < i; j++) {
                    System.out.print(" ");
                }

                // 处理星号
                for (int j = 0; j < n - i; j++) {
                    System.out.print("* ");  // 注意加空格
                }
                System.out.println();
            }
        }
    }


    // 60： BC63 菱形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的菱形图案。
    输入描述：
    多组输入，一个整数（2~20）。

    输出描述：
    针对每行输入，输出用“ * ”组成的菱形，每个“ * ”后面有一个空格。

    示例1
    输入：
    2
    输出：
    *
    **
    ***
    **
    *
    示例2
    输入：
    3
    输出：
    *
    **
    ***
    ****
    ***
    **
    *
    示例3
    输入：
    4
    输出：
    *
    **
    ***
    ****
    *****
    ****
    ***
    **
    *
    */

    public static void main60(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            // 上半部分:
            for (int i = 0; i < n; i++) {
                // 上半部分: 空格处理
                for (int j = 0; j < n - i; j++) {
                    System.out.print(" ");
                }

                // 上半部分: 星号处理
                for (int j = 0; j <= i; j++) {
                    System.out.print("* "); // 注意附加空格
                }
                System.out.println();
            }

            // 下半部分处理比上半部分多了 一个 1
            for (int i = 0; i < n + 1; i++) {
                // 空格处理
                for (int j = 0; j < i; j++) {
                    System.out.print(" ");
                }

                // 星号处理
                for (int j = 0; j < n + 1 - i; j++) {
                    System.out.print("* "); // 注意附加空格
                }
                System.out.println();
            }

        }
    }


    // 61: BC64 K形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的K形图案。
    输入描述：
    多组输入，一个整数（2~20）。

    输出描述：
    针对每行输入，输出用“ * ”组成的K形，每个“ * ”后面有一个空格。
    示例1
    输入：
    2
    输出：
    * **
    **
    *
    **
    ***
    示例2
    输入：
    3
    输出：
    * ***
    ***
    **
    *
    **
    ***
    ****
    示例3
    输入：
    4
    输出：
    * ****
    ****
    ***
    **
    *
    **
    ***
    ****
    *****
    */
    public static void main61(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            // 处理上部分:
            for (int i = 0; i < n; i++) {
                // 处理星号
                for (int j = 0; j <= n - i; j++) {
                    System.out.print("* "); // 注意附加空格
                }
                System.out.println();
            }

            // 处理下半部分: 比上半部分多了一个 +1
            for (int i = 0; i < n + 1; i++) {
                // 处理星号
                for (int j = 0; j <= i; j++) {
                    System.out.print("* "); // 注意附加空格
                }
                System.out.println();
            }
        }
    }


    // 62: BC65 箭形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的箭形图案。
    输入描述：
    本题多组输入，每行一个整数（2~20）。
    输出描述：
    针对每行输入，输出用“ * ”组成的箭形。

    示例1
    输入：
    2
    输出：
    *
    **
    ***
    **
    *
    示例2
    输入：
    3
    复制
    输出：
    *
    **
    ***
    ****
    ***
    **
    *
    示例3
    输入：
    4
    输出：
    *
    **
    ***
    ****
    *****
    ****
    ***
    **
    *
    */
    public static void main62(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();

            // 上半部分:处理
            for (int i = 0; i < n; i++) {
                // 空格处理: 两个空格为一组
                for (int j = 0; j < n - i; j++) {
                    System.out.print("  ");  // 空格两个为一组
                }

                // 星号处理
                for (int j = 0; j <= i; j++) {
                    System.out.print("*");
                }
                System.out.println();
            }

            // 下部分:比上部分多了一行
            for (int i = 0; i < n + 1; i++) {
                // 空格处理: 两个空格为一组
                for (int j = 0; j < i; j++) {
                    System.out.print("  ");
                }

                // 星号处理
                for (int j = 0; j < n + 1 - i; j++) {
                    System.out.print("*");
                }
                System.out.println();
            }
        }
    }


    // 63: BC66 反斜线形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的反斜线形图案。
    输入描述：
    多组输入，一个整数（2~20），表示输出的行数，也表示组成反斜线的“ * ”的数量。

    输出描述：
    针对每行输入，输出用“ * ”组成的反斜线。
    示例1
    输入：
    4
    输出：
    *
    *
    *
    *
    示例2
    输入：
    5
    输出：
    *
    *
    *
    *
    *
    */
    // 方式一:
    public static void main63(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();

            // 将字符串转换 基本数据类型
            int n = Integer.parseInt(
                    str); // 注意已经是字符串了就不要加“双引号”了
            for (int i = 0; i < n; i++) {
                //打印空格
                for (int j = 0; j < i; j++) {
                    System.out.print(" ");
                }
                // 打印星号
                System.out.println("*");
            }
        }
    }

    // 方式二:
    public static void main63$2(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNextLine()) {
            String str = scanner.nextLine();

            // 将字符串转换为 基本数据类型
            int n = Integer.parseInt(
                    str); // 已经是字符串了就不要再加双引号了

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    // 行号 == 列号 打印星号
                    if (i == j) {
                        System.out.print("*");
                    } else {  // 否则打印空格
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }
    }


    // 64：BC67 正斜线形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的正斜线形图案。
    输入描述：
    多组输入，一个整数（2~20），表示输出的行数，也表示组成正斜线的“ * ”的数量。
    输出描述：
    针对每行输入，输出用“ * ”组成的正斜线。
    示例1
    输入：
    4
    输出：

       *
      *
     *
    *
    示例2
    输入：
    5
    输出：
        *
       *
      *
     *
    *
    */
    // 方式一
    public static void main64(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String str = scanner.nextLine();

            // 将字符串转为为 基本数据类型
            int n = Integer.parseInt(
                    str);  // 已经是字符串了就不要再加“双引号”了
            for (int i = 0; i < n; i++) {
                // 注意一个行的空格的个数是，n -1个的
                // 打印空格
                for (int j = 0; j < n - 1 - i; j++) {
                    System.out.print(" ");
                }
                System.out.println("*");
            }
        }
    }

    // 方式二;
    public static void main64$2(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String str = scanner.nextLine();

            // 将字符串转为基本数据类型
            int n = Integer.parseInt(
                    str); // 已经是字符串了就不要加“双引号”了

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    // 行 + 列 = n -1; 打印星号
                    if (i + j == n - 1) {
                        System.out.print("*");
                    } else {  // 否则打印空格
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }
    }

    // 65： BC68 X形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的X形图案。
    输入描述：
    多组输入，一个整数（2~20），表示输出的行数，也表示组成“X”的反斜线和正斜线的长度。
    输出描述：
    针对每行输入，输出用“ * ”组成的X形图案。

    示例1
    输入：
    5
    输出：
    *   *
     * *
      *
     * *
    *   *
    示例2
    输入：
    6
    输出：
    *    *
     *  *
      **
      **
     *  *
    *    *
    */
    public static void main65(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String str = scanner.nextLine();

            // 将字符串转换为 int 基本数据类型
            int n = Integer.parseInt(str); // 已经是字符串了就不要加"双引号"了

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    // 打印反斜线: 行 == 列
                    if (i == j) {
                        System.out.print("*");
                    } else if (i + j == n - 1) {  // 打印正斜线: 行 + 列 = n -1
                        System.out.print("*");
                    } else { // 打印空格
                        System.out.print(" ");
                    }
                }
                System.out.println();
            }
        }
    }


    // 66: BC69 空心正方形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的“空心”正方形图案。
    输入描述：
    多组输入，一个整数（3~20），表示输出的行数，也表示组成正方形边的“ * ”的数量。
    输出描述：
    针对每行输入，输出用“ * ”组成的“空心”正方形，每个“ * ”后面有一个空格。
    示例1
    输入：
    4
    输出：
    * * * *
    *     *
    *     *
    * * * *
    示例2
    输入：
    5
    输出：
    * * * * *
    *       *
    *       *
    *       *
    * * * * *
    */

    public static void main66(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String str = scanner.next();

            // 将字符串转换为 int 基本数据类型
            int n = Integer.parseInt(
                    str); // 已经是字符串了就不要加 "双引号"了

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    // 起始行和结尾行: i == 0 || i = n-1 星号覆盖
                    if (i == 0 || i == n - 1) {
                        System.out.print("* "); // 附加空格
                    } else if (j == 0 ||
                            j == n - 1) { // 起始列和结尾列: j == 0 || j = n -1 星号覆盖
                        System.out.print("* ");  // 附加空格
                    } else {  // 其余空格处理: 这里以两个空格为一组
                        System.out.print("  ");
                    }
                }
                System.out.println();
            }
        }
    }


    // 67: BC70 空心三角形图案
    /*
    描述
    KiKi学习了循环，BoBo老师给他出了一系列打印图案的练习，该任务是打印用“ * ”组成的“空心”三角形图案。
    输入描述：
    多组输入，一个整数（3~20），表示输出的行数，也表示组成三角形边的“ * ”的数量。
    输出描述：
    针对每行输入，输出用“ * ”组成的“空心”三角形，每个“ * ”后面有一个空格。
    示例1
    输入：
    4
    输出：
    *
    * *
    *   *
    * * * *
    示例2
    输入：
    5
    输出：
    *
    * *
    *   *
    *     *
    * * * * *
    */
    public static void main67(String[] args) {
        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {
            String str = scanner.next();

            // 将字符串转换为 int 的基本数据类型
            int n = Integer.parseInt(
                    str); // 已经是字符串了就不要再附加 "双引号"了
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    //起始列，结尾行，i == j 星号覆盖
                    if ((j == 0) || (i == n - 1) || (i == j)) {
                        System.out.print("* "); // 附加空格
                    } else {  // 其余空格: 以两个空格为一组
                        System.out.print("  ");
                    }
                }
                System.out.println();
            }
        }
    }

}
